home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 2000 November: Tool Chest / Dev.CD Nov 00 TC Disk 1.toast / Sample Code / Graphics 3D / SetupGL / SetupDSp.c < prev    next >
Encoding:
Text File  |  2000-09-28  |  25.6 KB  |  830 lines  |  [TEXT/CWIE]
  1. /*
  2.     File:        SetupDSp.c
  3.  
  4.     Contains:    Functions to enable building and destorying a DSp fullscreen context
  5.  
  6.     Written by:    Geoff Stahl (ggs)
  7.  
  8.     Copyright:    Copyright © 1999 Apple Computer, Inc., All Rights Reserved
  9.  
  10.     Change History (most recent first):
  11.  
  12.          <7>     3/21/00    ggs     Added windowed mode and clean up various implementation details
  13.          <6>     2/22/00    ggs     fix fades
  14.          <5>     1/26/00    ggs     Add fade code back in, ensure NULL pointer/context checks are in
  15.          <4>     1/24/00    ggs     add new disclaimer, protection from NULL dispose, better
  16.                                     software renderer handling
  17.          <3>    12/18/99    ggs     Fixed err use before init
  18.          <2>    12/18/99    ggs     Fix headers
  19.          <1>    11/28/99    ggs     Initial add.  Split of just DSp handling functions.  Added total
  20.                                     device RAM checks, better step downs using actual supported
  21.                                     resolutions. Need to add user verify for contexts that require
  22.                                     it, integration of this in context step down, and a freq bit
  23.                                     field.
  24.          <1>    11/11/99    ggs     Initial Add
  25.  
  26.     Disclaimer:    You may incorporate this sample code into your applications without
  27.                 restriction, though the sample code has been provided "AS IS" and the
  28.                 responsibility for its operation is 100% yours.  However, what you are
  29.                 not permitted to do is to redistribute the source as "DSC Sample Code"
  30.                 after having made changes. If you're going to re-distribute the source,
  31.                 we require that you make it clear in the source that the code was
  32.                 descended from Apple Sample Code, but that you've made changes.
  33. */
  34.  
  35.  
  36. // Usage notes: 
  37. // kUseFades enables gamma fades for activates and deactivates
  38. #define kUseFades
  39.  
  40. //kUseRAMCheck enables estimated video card RAM checks
  41. #define kUseRAMCheck
  42.  
  43.  
  44. // system includes ----------------------------------------------------------
  45.  
  46. #include <fp.h>
  47.  
  48. #include <string.h>
  49.  
  50.  
  51. // project includes ---------------------------------------------------------
  52.  
  53. #include "Error Handler.h"
  54. #include "SetupDSp.h"
  55.  
  56. // globals (internal/private) -----------------------------------------------
  57.  
  58. enum 
  59. { 
  60.     kMaxNumRes = 64, // max number of resolution slots
  61.     kMaxRefreshFreq = 75 
  62. }; 
  63.  
  64. Boolean gDSpStarted = false;
  65. Boolean gNeedFade = false;
  66.  
  67. // prototypes (internal/private) --------------------------------------------
  68.  
  69. DSpContextReference * ReserveUnusedDevices (GDHandle hGD);
  70. OSStatus FreeUnusedDevices (GDHandle hGD, DSpContextReference ** ppContextRefUnused);
  71. void BuildResolutionList (GDHandle hGD, Point * pResList, UInt32 * pFreqList);
  72. OSStatus DoDeviceRAMCheck (pstructGLInfo pcontextInfo, Point * pResList, UInt32 * pFreqList, GLint depthSizeSupport);
  73. Boolean DoContextStepDown (pstructGLInfo pcontextInfo, DSpContextAttributes * pContextAttributes, Point * pResList, UInt32 * pFreqList);
  74.  
  75.  
  76. // functions (internal/private) ---------------------------------------------
  77.  
  78. // ReserveUnusedDevices
  79.  
  80. // reserves contexts on unused devices to vprevent their selection by DSp, returns list of these devices
  81.  
  82. DSpContextReference * ReserveUnusedDevices (GDHandle hGD)
  83. {
  84.     DSpContextAttributes theContextAttributes;
  85.     DSpContextReference * pContextRefUnused = NULL;
  86.     GDHandle hDevice = DMGetFirstScreenDevice (true); // check number of screens
  87.     OSStatus err = noErr;
  88.     DisplayIDType displayID = 0;
  89.     short numDevices = 0, indexDevice = 0;
  90.     
  91.     do
  92.     {
  93.         numDevices++;
  94.         hDevice = DMGetNextScreenDevice (hDevice, true);
  95.     }
  96.     while (hDevice);
  97.     numDevices--; // only count unused screens
  98.     if (numDevices)
  99.     {
  100.         pContextRefUnused = (DSpContextReference *) NewPtr ((long) sizeof (DSpContextReference) * numDevices);
  101.         hDevice = DMGetFirstScreenDevice (true); // check number of screens
  102.         do
  103.         {
  104.             if (hDevice != hGD)    // if this device is not the one the user chose
  105.             {
  106.                 if (noErr == DSpReportError (DMGetDisplayIDByGDevice (hDevice, &displayID, false)))
  107.                     if (noErr == DSpReportError (DSpGetFirstContext (displayID, &pContextRefUnused [indexDevice]))) // get a context and
  108.                         if (noErr == DSpReportError (DSpContext_GetAttributes (pContextRefUnused [indexDevice], &theContextAttributes))) // find attributes
  109.                             DSpReportError (DSpContext_Reserve (pContextRefUnused [indexDevice], &theContextAttributes)); // reserve it
  110.                 indexDevice++;
  111.             }
  112.             hDevice = DMGetNextScreenDevice (hDevice, true);
  113.         }
  114.         while (hDevice);
  115.     }
  116.     return pContextRefUnused;
  117. }
  118.  
  119. // --------------------------------------------------------------------------
  120.  
  121. // FreeUnusedDevices
  122.  
  123. // frees screen that were previously reserved to prevent selection
  124.  
  125. OSStatus FreeUnusedDevices (GDHandle hGD, DSpContextReference ** ppContextRefUnused)
  126. {
  127.     OSStatus err = noErr;
  128.     GDHandle hDevice = DMGetFirstScreenDevice (true); // check number of screens
  129.     short indexDevice = 0;
  130.  
  131.     do
  132.     {
  133.         if (hDevice != hGD)    // if this device is not the one the user chose
  134.         {
  135.             err = DSpContext_Release (*ppContextRefUnused [indexDevice]); // release it
  136.             DSpReportError (err);
  137.             indexDevice++;
  138.         }
  139.         hDevice = DMGetNextScreenDevice (hDevice, true);
  140.     }
  141.     while (hDevice);
  142.     
  143.     if (*ppContextRefUnused)
  144.         DisposePtr ((Ptr) *ppContextRefUnused);
  145.     *ppContextRefUnused = NULL;
  146.     return err;
  147. }
  148.  
  149. // --------------------------------------------------------------------------
  150.  
  151. // BuildResolutionList
  152.  
  153. // builds a list of supported resolutions and frequencies for GDevice
  154.  
  155. void BuildResolutionList (GDHandle hGD, Point * pResList, UInt32 * pFreqList)
  156. {
  157.     DSpContextAttributes theContextAttributes;
  158.     DSpContextReference currContext;
  159.     OSStatus err;
  160.     DisplayIDType displayID = 0;
  161.     short i;
  162.     
  163.     for (i = 0; i < kMaxNumRes; i++)    // clear resolution list
  164.     {
  165.         pResList [i].h = 0x7FFF;
  166.         pResList [i].v = 0x7FFF;
  167.         pFreqList [i] = 0;            // some context require certain frequencies find highest for each (not higher than 85
  168.     }
  169.  
  170.     err = DMGetDisplayIDByGDevice (hGD, &displayID, true);
  171.     if (noErr != err)
  172.         ReportErrorNum ("DMGetDisplayIDByGDevice error", err);
  173.     else
  174.     {
  175.         if (noErr == DSpReportError (DSpGetFirstContext (displayID, &currContext)))
  176.             do
  177.             {    
  178.                 // insertion sort into resolution list
  179.                 if (noErr == DSpReportError (DSpContext_GetAttributes (currContext, &theContextAttributes)))
  180.                 {
  181.                     Point pntTemp;
  182.                     Boolean fDone = false;
  183.                     short i = 0;
  184.                     while ((i < kMaxNumRes) && (!fDone))
  185.                     {
  186.                         if ((theContextAttributes.displayWidth == pResList [i].h) && (theContextAttributes.displayHeight == pResList [i].v)) //skip
  187.                         {
  188.                             if ((pFreqList [i] == 0) || ((theContextAttributes.frequency <= (kMaxRefreshFreq << 16)) && (theContextAttributes.frequency > pFreqList [i])))
  189.                                 pFreqList [i] = theContextAttributes.frequency;
  190.                             break;
  191.                         }
  192.                         if (theContextAttributes.displayWidth * theContextAttributes.displayHeight < pResList [i].h * pResList [i].v) //insert
  193.                         {
  194.                             pntTemp = pResList [i];
  195.                             pResList [i].h = theContextAttributes.displayWidth;
  196.                             pResList [i].v = theContextAttributes.displayHeight;
  197.                             pFreqList [i] = theContextAttributes.frequency;
  198.                             fDone = true;
  199.                         }
  200.                         i++;
  201.                     }
  202.                     // i points to next element to switch; finish array swaps (if 
  203.                     while ((i < kMaxNumRes) && (fDone))
  204.                     {
  205.                         Point pntSwitch = pResList [i];
  206.                         pResList [i++] = pntTemp;
  207.                         pntTemp = pntSwitch;
  208.                     }
  209.                 }
  210.                 err = DSpGetNextContext (currContext, &currContext);
  211.                 if (noErr != err)
  212.                 {
  213.                     if (kDSpContextNotFoundErr != err) 
  214.                         DSpReportError (err);
  215.                     currContext = 0;    // ensure we drop out
  216.                 }
  217.             } 
  218.             while (currContext);
  219.         else
  220.             ReportErrorNum ("DSpGetFirstContext error", err);
  221.     }    
  222.     // zeroize unused elements
  223.     for (i = 0; i < kMaxNumRes; i++)
  224.         if ((pResList [i].h == 0x7FFF) || (pResList [i].v == 0x7FFF))
  225.         {
  226.             pResList [i].h = 0;
  227.             pResList [i].v = 0;
  228.         }
  229. }
  230.  
  231. // --------------------------------------------------------------------------
  232.  
  233. // DoDeviceRAMCheck
  234.  
  235. // checks requested allocation against device RAM
  236. // Note: may modify pcontextInfo
  237. // this should be equal or less strigent than OpenGL actual allocation to avoid failing on valid drawables
  238.  
  239. OSStatus DoDeviceRAMCheck (pstructGLInfo pcontextInfo, Point * pResList, UInt32 * pFreqList, GLint depthSizeSupport)
  240. {
  241.     float frontBufferFactor = 1.0, backBufferFactor = 0.0; // amount of screen(front) or request(back) sized buffers required, in bytes
  242.     Point pntFrontBuffer; // size of front buffer that wil be allocated
  243.     short i, indexFrontBuffer; 
  244.     OSStatus err = noErr;
  245.  
  246.     // must take into account the entire front buffer, so figure out what screen resolution we are really going to use
  247.     // find front buffer for request
  248.     i = 0;
  249.     while (((pResList [i].h < pcontextInfo->width) || (pResList [i].v < pcontextInfo->height)) &&
  250.            ((pResList [i].h != 0) || (pResList [i].v != 0)) &&
  251.            (i < kMaxNumRes))
  252.         i++;
  253.     // save front buffer sizes
  254.     pntFrontBuffer.h = pResList [i].h;
  255.     pntFrontBuffer.v = pResList [i].v;
  256.     // if we have a valid frequnecy for the context set it (to ensure a good selection
  257.     pcontextInfo->freq = pFreqList [i] >> 16;
  258.     indexFrontBuffer = i;
  259.     
  260.     // front buffers required
  261.     if (16 == pcontextInfo->pixelDepth)
  262.         frontBufferFactor *= 2.0;
  263.     else if (32 == pcontextInfo->pixelDepth)
  264.         frontBufferFactor *= 4.0;
  265.         
  266.     // back buffers required    
  267.     backBufferFactor = 0.0;
  268.     i = 0;
  269.     while (64 > i)
  270.         if (AGL_DOUBLEBUFFER == pcontextInfo->aglAttributes[i++])
  271.         {
  272.             if (16 == pcontextInfo->pixelDepth)
  273.                 backBufferFactor = 2.0;
  274.             else if (32 == pcontextInfo->pixelDepth)
  275.                 backBufferFactor = 4.0;
  276.             break;
  277.         }
  278.     i = 0;
  279.     while (64 > i)
  280.         if (AGL_DEPTH_SIZE == pcontextInfo->aglAttributes[i++])
  281.         {
  282.             short requestDepth = pcontextInfo->aglAttributes[i];
  283.             GLint bit = 0x00000001;
  284.             short currDepth = 0, prevDepth = 0;
  285. //            if (depthSizeSupport)
  286. //            {
  287.             do
  288.             {
  289.                 if (bit & depthSizeSupport)    // if the card supports the depth
  290.                 {
  291.                     prevDepth = currDepth;
  292.                     switch (bit)
  293.                     {
  294.                         case AGL_1_BIT:
  295.                             currDepth = 1;
  296.                             break;
  297.                         case AGL_2_BIT:
  298.                             currDepth = 2;
  299.                             break;
  300.                         case AGL_3_BIT:
  301.                             currDepth = 3;
  302.                             break;
  303.                         case AGL_4_BIT:
  304.                             currDepth = 4;
  305.                             break;
  306.                         case AGL_5_BIT:
  307.                             currDepth = 5;
  308.                             break;
  309.                         case AGL_6_BIT:
  310.                             currDepth = 6;
  311.                             break;
  312.                         case AGL_8_BIT:
  313.                             currDepth = 8;
  314.                             break;
  315.                         case AGL_10_BIT:
  316.                             currDepth = 10;
  317.                             break;
  318.                         case AGL_12_BIT:
  319.                             currDepth = 12;
  320.                             break;
  321.                         case AGL_16_BIT:
  322.                             currDepth = 16;
  323.                             break;
  324.                         case AGL_24_BIT:
  325.                             currDepth = 24;
  326.                             break;
  327.                         case AGL_32_BIT:
  328.                             currDepth = 32;
  329.                             break;
  330.                         case AGL_48_BIT:
  331.                             currDepth = 48;
  332.                             break;
  333.                         case AGL_64_BIT:
  334.                             currDepth = 64;
  335.                             break;
  336.                         case AGL_96_BIT:
  337.                             currDepth = 96;
  338.                             break;
  339.                         case AGL_128_BIT:
  340.                             currDepth = 128;
  341.                             break;
  342.                     }
  343.                 }
  344.                 bit *= 2;
  345.             } while (!((requestDepth > prevDepth) && (requestDepth <= currDepth)) && (bit < AGL_128_BIT + 1));
  346. //            }
  347. //            else // no card depth support info
  348. //                currDepth = requestDepth;  // we don't have card info thus assume we can support exact depth requested (may fail later but will always be equal or less stringent)
  349.             if ((AGL_128_BIT >= bit) && (0 != currDepth))
  350.                 backBufferFactor += (float) currDepth / 8.0;
  351.             break;
  352.         }
  353.         
  354.     // What we now have:
  355.     //  pcontextInfo->width, height: request width and height
  356.     //  pResList: sorted list of resolutions supported on this display
  357.     //  pntFrontBuffer : size of front buffer that will currently be allocated
  358.     //  indexFrontBuffer: position in array of current front buffer request
  359.     //  frontBufferFactor: number of screen resolution size buffers that will be needed
  360.     //  backBufferFactor: number of request size buffers that will be needed
  361.     
  362.     // if we see zero VRAM here we must be looking at the software renderer thus this check is moot.
  363.     if (pcontextInfo->VRAM == 0)
  364.     {
  365.         // no changes required
  366.         return noErr;
  367.     }
  368.     
  369.     
  370.     // find a context size that can support our texture requirements in the current total VRAM
  371.     if ((pcontextInfo->VRAM - pcontextInfo->textureRAM) < (pntFrontBuffer.h * pntFrontBuffer.v * frontBufferFactor + 
  372.                                                            pcontextInfo->width * pcontextInfo->height * backBufferFactor))
  373.     {
  374.         if (pcontextInfo->fDepthMust && pcontextInfo->fSizeMust)
  375.         {
  376.             // cannot accomdate request
  377.             ReportError ("Not enough total VRAM for drawable and textures (depth buffer and pixel size must be as requested)");
  378.             return err;
  379.         }
  380.         else if (pcontextInfo->fSizeMust) // if we can adjust the size, try adjusting the 
  381.         {
  382.             // try 16 bit if must size is true
  383.             if ((pcontextInfo->pixelDepth > 16) &&
  384.                 (pcontextInfo->VRAM - pcontextInfo->textureRAM) > (pntFrontBuffer.h * pntFrontBuffer.v * frontBufferFactor / 2.0 + 
  385.                                                                       pcontextInfo->width * pcontextInfo->height * (backBufferFactor - 2.0)))
  386.                 pcontextInfo->pixelDepth = 16;
  387.             else
  388.             {
  389.                 // cannot accomdate request
  390.                 ReportError ("Not enough total VRAM for drawable and textures");
  391.                 return err;
  392.             }
  393.         }
  394.         else // can adjust size and might be able to adjust depth
  395.         {    // make drawable fit
  396.             Boolean fFound = false;
  397.             // see if we can just adjust the pixel depth
  398.             if ((pcontextInfo->pixelDepth > 16) &&    // if we are requesting 32 bit
  399.                 (!pcontextInfo->fDepthMust) &&         // if we can adjust the pixel depth
  400.                 (pcontextInfo->VRAM - pcontextInfo->textureRAM) > (pntFrontBuffer.h * pntFrontBuffer.v * frontBufferFactor / 2.0 + 
  401.                                                                       pcontextInfo->width * pcontextInfo->height * (backBufferFactor - 2.0)))
  402.             {
  403.                 fFound = true;
  404.                 pcontextInfo->pixelDepth = 16;
  405.             }
  406.             else // pixel depth alone wont do it
  407.             {
  408.                 i = indexFrontBuffer - 1;
  409.                 while (i >= 0)
  410.                 {
  411.                     //
  412.                     if ((pcontextInfo->VRAM - pcontextInfo->textureRAM) > (pResList [i].h * pResList [i].v * frontBufferFactor + 
  413.                                                                               pResList [i].h * pResList [i].v * backBufferFactor))
  414.                     {
  415.                         fFound = true;
  416.                         pcontextInfo->width = pResList [i].h;
  417.                         pcontextInfo->height = pResList [i].v;
  418.                         pcontextInfo->freq = pFreqList [i] >> 16;
  419.                         break;
  420.                     }
  421.                     else if ((pcontextInfo->pixelDepth > 16) &&    // if we are requesting 32 bit
  422.                              (!pcontextInfo->fDepthMust) &&     // if we can adjust the pixel depth
  423.                              (pcontextInfo->VRAM - pcontextInfo->textureRAM) > (pResList [i].h * pResList [i].v * frontBufferFactor / 2.0 + 
  424.                                                                                 pResList [i].h * pResList [i].v * (backBufferFactor - 2.0)))
  425.                     {
  426.                         fFound = true;
  427.                         pcontextInfo->width = pResList [i].h;
  428.                         pcontextInfo->height = pResList [i].v;
  429.                         pcontextInfo->freq = pFreqList [i] >> 16;
  430.                         pcontextInfo->pixelDepth = 16;
  431.                         break;
  432.                     }
  433.                     i--;
  434.                 }
  435.                 // we tried the smallest screen size and still need to use less VRAM, adjust backbuffer to what is available
  436.                 if ((!fFound) && (((pcontextInfo->VRAM - pcontextInfo->textureRAM) - pResList [0].h * pResList [0].v * frontBufferFactor) > 0))
  437.                 {
  438.                     float factor;
  439.                     fFound = true;
  440.                     factor = sqrt((float) (pcontextInfo->width * pcontextInfo->height * backBufferFactor) / 
  441.                                   (float) ((pcontextInfo->VRAM - pcontextInfo->textureRAM) - pResList [0].h * pResList [0].v * frontBufferFactor));
  442.                     pcontextInfo->width /= factor;
  443.                     pcontextInfo->height /= factor;
  444.                     pcontextInfo->freq = pFreqList [0] >> 16;
  445.                 }
  446.             }
  447.             if (!fFound)
  448.             {
  449.                 // cannot accomdate request
  450.                 ReportError ("Not enough total VRAM for drawable and textures");
  451.                 return err;
  452.             }
  453.  
  454.         }
  455.     }
  456.     return noErr;
  457. }
  458.  
  459. // --------------------------------------------------------------------------
  460.  
  461. // DoContextStepDown
  462.  
  463. // steps down through frequencies, depths and sizes to try to find a valid context
  464. // bounded by flags for SizeMust and DepthMust
  465. // Note: may modify pcontextInfo
  466.  
  467. Boolean DoContextStepDown (pstructGLInfo pcontextInfo, DSpContextAttributes * pContextAttributes, Point * pResList, UInt32 * pFreqList)
  468. {
  469.     // find current resolution
  470.     short i = 0; 
  471.     while (((pResList [i].h <= pContextAttributes->displayWidth) || (pResList [i].v <= pContextAttributes->displayHeight)) && 
  472.             ((pResList [i].h != 0) || (pResList [i].v != 0)) &&
  473.             (i < kMaxNumRes))
  474.         i++;
  475.     i--; // i points to index of current resolution
  476.     
  477.     if (pcontextInfo->fSizeMust) // adjust depth only
  478.     {
  479.         if (pcontextInfo->pixelDepth > 16)    // also try pixel depth step down
  480.         {
  481.             pContextAttributes->displayBestDepth = 16;
  482.             pContextAttributes->backBufferBestDepth = 16;
  483.         }
  484.         else
  485.             return false; // no more options to try
  486.     }
  487.     else if (pcontextInfo->fDepthMust) // adjust size only
  488.     {
  489.         if (i > 0)
  490.         {
  491.             i--; // i was pointing at current resolution, now it is pointing at new resolution to try
  492.             // set new resolution
  493.             pContextAttributes->displayWidth = pResList [i].h;
  494.             pContextAttributes->displayHeight = pResList [i].v;
  495.             pcontextInfo->freq = pFreqList [i] >> 16;
  496.         }
  497.         else
  498.             return false;
  499.     }
  500.     else // adjust size and depth
  501.     {
  502.         if (pContextAttributes->displayBestDepth > 16)
  503.         {
  504.             pContextAttributes->displayBestDepth = 16;
  505.             pContextAttributes->backBufferBestDepth = 16;
  506.         }
  507.         else if (i > 0)
  508.         {
  509.             i--; // i was pointing at current resolution, now it is pointing at new resolution to try
  510.             // reset pixel depth
  511.             pContextAttributes->displayBestDepth = pcontextInfo->pixelDepth;
  512.             pContextAttributes->backBufferBestDepth = pcontextInfo->pixelDepth;
  513.             // set new resolution
  514.             pContextAttributes->displayWidth = pResList [i].h;
  515.             pContextAttributes->displayHeight = pResList [i].v;
  516.             pcontextInfo->freq = pFreqList [i] >> 16;
  517.         }
  518.         else
  519.             return false;
  520.             
  521.     }
  522.     return true;
  523. }
  524.  
  525. #pragma mark -
  526. // functions (public) -------------------------------------------------------
  527.  
  528. // StartDSp
  529.  
  530. // handles starting up DrawSprocket
  531.  
  532. OSStatus StartDSp (void)
  533. {
  534.     OSStatus err = noErr;
  535.     
  536.     if (!gDSpStarted)
  537.     {
  538.         // check for DSp
  539.         if ((Ptr) kUnresolvedCFragSymbolAddress == (Ptr) DSpStartup) 
  540.         {
  541.             ReportError ("DSp not installed");
  542.             return noErr;
  543.         }    
  544.  
  545.         err = DSpReportError (DSpStartup()); // start DSp
  546.         if (noErr != err)
  547.             return err;
  548.         else
  549.             gDSpStarted = true;
  550.     }
  551.     return err;        
  552. }
  553.  
  554. // --------------------------------------------------------------------------
  555.  
  556. // ShutdownDSpContext
  557.  
  558. // shuts down DrawSprocket
  559.  
  560. void ShutdownDSp (void)
  561. {
  562.     if (gDSpStarted)
  563.     {
  564.         DSpShutdown ();
  565.         gDSpStarted = false;
  566.     }
  567. }
  568.  
  569. #pragma mark -
  570. // --------------------------------------------------------------------------
  571.  
  572. // BuildDSpContext
  573.  
  574. // contexInfo and tries to allocate the corresponding DSp context
  575.  
  576. // Inputs:     hGD: GDHandle to device to look at
  577. //            pcontextInfo: request and requirements for cotext and drawable
  578.  
  579. // Outputs: *pdspContext as allocated
  580. //            pcontextInfo:  allocated parameters
  581.  
  582. // if fail to allocate: pdspContext will be NULL
  583. // if error: will return error pdspContext will be NULL
  584.  
  585. OSStatus BuildDSpContext (DSpContextReference* pdspContext, GDHandle hGD, GLint depthSizeSupport, pstructGLInfo pcontextInfo)
  586. {
  587.     DSpContextAttributes theContextAttributes, foundAttributes;
  588.     DSpContextReference * pContextRefUnused;
  589.     UInt32 aFreqList [kMaxNumRes];
  590.     Point aResList [kMaxNumRes]; // list for resolution information
  591.     OSStatus err = noErr;
  592.     
  593.     *pdspContext = 0;
  594.  
  595.     if (!gDSpStarted)
  596.     {
  597.         // check for DSp
  598.         if ((Ptr) kUnresolvedCFragSymbolAddress == (Ptr) DSpStartup) 
  599.         {
  600.             ReportError ("DSp not installed");
  601.             return noErr;
  602.         }    
  603.  
  604.         err = DSpReportError (DSpStartup()); // start DSp
  605.         if (noErr != err)
  606.         {
  607.             return err;
  608.         }
  609.         else
  610.             gDSpStarted = true;
  611.     }        
  612.  
  613.     // reserve contexts on other screens to prevent their selection
  614.     pContextRefUnused = ReserveUnusedDevices (hGD);
  615.     
  616.     // build resolution list
  617.     BuildResolutionList (hGD, aResList, aFreqList);
  618.     
  619.     // handle default pixel depths
  620.     if (pcontextInfo->pixelDepth == 0)    // default
  621.     {
  622.         pcontextInfo->pixelDepth = (**(**hGD).gdPMap).pixelSize;
  623.         if (pcontextInfo->pixelDepth < 16)
  624.             pcontextInfo->pixelDepth = 16;
  625.     }
  626.  
  627. #ifdef kUseRAMCheck
  628.     if (noErr != DoDeviceRAMCheck (pcontextInfo, aResList, aFreqList, depthSizeSupport))
  629.         return err;
  630. #endif // kUseRAMCheck
  631.  
  632.     // Note: DSp < 1.7.3 REQUIRES the back buffer attributes even if only one buffer is required
  633.     memset(&theContextAttributes, 0, sizeof (DSpContextAttributes));
  634.     theContextAttributes.displayWidth                = pcontextInfo->width;
  635.     theContextAttributes.displayHeight                = pcontextInfo->height;
  636.     theContextAttributes.displayBestDepth            = pcontextInfo->pixelDepth;
  637.     theContextAttributes.backBufferBestDepth        = pcontextInfo->pixelDepth;
  638.     do
  639.     {    
  640.         theContextAttributes.frequency                = pcontextInfo->freq * 0x10000;
  641.         theContextAttributes.colorNeeds                = kDSpColorNeeds_Require;
  642.         theContextAttributes.displayDepthMask        = kDSpDepthMask_All;
  643.         theContextAttributes.backBufferDepthMask    = kDSpDepthMask_All;
  644.         theContextAttributes.pageCount                = 1; // only the front buffer is needed
  645.         err = DSpFindBestContext(&theContextAttributes, pdspContext);
  646.         if (noErr != err)    // if we had any errors, reset for next try
  647.             if (!DoContextStepDown (pcontextInfo, &theContextAttributes, aResList, aFreqList))
  648.                 break; // have run out of options
  649.     } while (err == kDSpContextNotFoundErr);
  650.  
  651.     // check find best context errors
  652.     if (kDSpContextNotFoundErr == err)
  653.     {    
  654.         *pdspContext = 0;
  655.         return noErr;
  656.     }
  657.     else if (noErr != err)
  658.     {
  659.         DSpReportError (err);
  660.         *pdspContext = 0;
  661.         return err;
  662.     }
  663.     
  664.     err = DSpReportError (DSpContext_GetAttributes (*pdspContext, &foundAttributes));
  665.     if (noErr != err)
  666.     {
  667.         *pdspContext = 0;
  668.         return err;
  669.     }
  670.     // reset width and height to full screen and handle our own centering
  671.     // HWA will not correctly center less than full screen size contexts
  672.     theContextAttributes.displayWidth         = foundAttributes.displayWidth;
  673.     theContextAttributes.displayHeight         = foundAttributes.displayHeight;
  674.     theContextAttributes.pageCount            = 1; // only the front buffer is needed
  675.     theContextAttributes.contextOptions        = 0 | kDSpContextOption_DontSyncVBL; // no page flipping and no VBL sync needed
  676.  
  677.     err = DSpReportError (DSpContext_Reserve(*pdspContext, &theContextAttributes )); // reserve our context
  678.     if (noErr != err)
  679.     {
  680.         *pdspContext = 0;
  681.         return err;
  682.     }
  683.     if (gNeedFade == true)
  684.     {
  685.         DSpReportError (DSpContext_CustomFadeGammaOut (NULL, NULL, fadeTicks));
  686.         gNeedFade = false;
  687.     }
  688.     err = DSpReportError (DSpContext_SetState (*pdspContext, kDSpContextState_Active)); // activate our context
  689.     if (noErr != err)
  690.     {
  691.         DSpContext_Release (*pdspContext);
  692.         DSpReportError (DSpContext_CustomFadeGammaIn (NULL, NULL, fadeTicks));
  693.         *pdspContext = 0;
  694.         return err;
  695.     }
  696.  
  697.     FreeUnusedDevices (hGD, &pContextRefUnused);
  698.     
  699.     if (!pcontextInfo->fSizeMust)    // if we got whatever was available
  700.     {
  701.         // reset inputs to what was allocated (constrain aspect ratio)
  702.         // unless we ask for smaller, then leave the same
  703.         if ((pcontextInfo->width > foundAttributes.displayWidth) || (pcontextInfo->height > foundAttributes.displayHeight))
  704.         {
  705.             float hFactor = (float) pcontextInfo->width / (float) foundAttributes.displayWidth;
  706.             float vFactor = (float) pcontextInfo->height / (float) foundAttributes.displayHeight;
  707.             if (hFactor > vFactor)
  708.             {
  709.                 pcontextInfo->width = foundAttributes.displayWidth;
  710.                 pcontextInfo->height /= hFactor;    
  711.             }
  712.             else
  713.             {
  714.                 pcontextInfo->height = foundAttributes.displayHeight;
  715.                 pcontextInfo->width /= vFactor;    
  716.             }
  717.         }
  718.     }
  719.     // else still use inputs to allocate drawable
  720.     
  721.     pcontextInfo->freq = foundAttributes.frequency / 0x10000;
  722.     pcontextInfo->pixelDepth = foundAttributes.displayBestDepth;
  723.  
  724.     return noErr;
  725. }
  726.  
  727. //-----------------------------------------------------------------------------------------------------------------------
  728.  
  729. // Deactivates and dumps context
  730.  
  731. void DestroyDSpContext (DSpContextReference* pdspContext)
  732. {
  733.     if (gDSpStarted)
  734.     {
  735.         if (*pdspContext)
  736.         {
  737.             DSpContext_SetState(*pdspContext, kDSpContextState_Inactive );
  738.             DSpReportError (DSpContext_CustomFadeGammaIn (NULL, NULL, fadeTicks));
  739.             DSpContext_Release (*pdspContext);
  740.             *pdspContext = NULL;
  741.         }
  742.     }
  743. }
  744.  
  745.  
  746. #pragma mark -
  747. //-----------------------------------------------------------------------------------------------------------------------
  748.  
  749. OSStatus DSpContext_CustomFadeGammaIn (DSpContextReference inContext, const RGBColor *fadeColor,  long fadeTicks) 
  750. {
  751.     OSStatus err = noErr;
  752. #ifndef kUseFades
  753.     #pragma unused (inContext, fadeColor, fadeTicks)
  754. #else
  755.     RGBColor inZeroIntensityColor;
  756.     long currTick;
  757.     UInt16 step = 800 / fadeTicks;
  758.     short x, percent = 0;
  759.  
  760.     if (gDSpStarted)
  761.     {
  762.         if (fadeTicks == 0)
  763.             fadeTicks = 1;
  764.         if (fadeColor == NULL) 
  765.         {
  766.             inZeroIntensityColor.red = 0x0000;
  767.             inZeroIntensityColor.green = 0x0000;
  768.             inZeroIntensityColor.blue = 0x0000;
  769.         }
  770.         else 
  771.             inZeroIntensityColor = *fadeColor;
  772.         currTick = TickCount ();
  773.         for (x = 1; x <= fadeTicks; x++) 
  774.         {
  775.             percent =  step * x >> 3;
  776.             err = DSpContext_FadeGamma(inContext, percent, &inZeroIntensityColor);
  777.             if (err != noErr) 
  778.                 break;
  779.             while (currTick >= TickCount ()) 
  780.                 SystemTask ();
  781.             currTick = TickCount ();
  782.         }
  783.         if (err == noErr)
  784.             err = DSpContext_FadeGamma(inContext, 100, &inZeroIntensityColor);
  785.     }
  786. #endif // kUseFades
  787.     return err;
  788. }
  789.  
  790. //-----------------------------------------------------------------------------------------------------------------------
  791.  
  792. OSStatus DSpContext_CustomFadeGammaOut (DSpContextReference inContext, const RGBColor *fadeColor, long fadeTicks ) 
  793. {
  794.     
  795.     OSStatus err = noErr;
  796. #ifndef kUseFades
  797.     #pragma unused (inContext, fadeColor, fadeTicks)
  798. #else
  799.     RGBColor inZeroIntensityColor;
  800.     long currTick;
  801.     UInt16 step = 800 / fadeTicks;
  802.     short x, percent = 0;
  803.  
  804.     if (gDSpStarted)
  805.     {
  806.         if (fadeTicks == 0)
  807.             fadeTicks = 1;                                // ensure we do not have zero fade time
  808.         if (fadeColor == NULL) 
  809.         {
  810.             inZeroIntensityColor.red = 0x0000;
  811.             inZeroIntensityColor.green = 0x0000;
  812.             inZeroIntensityColor.blue = 0x0000;
  813.         }
  814.         else 
  815.             inZeroIntensityColor = *fadeColor;
  816.         currTick = TickCount ();
  817.         for (x = fadeTicks - 1; x >= 0; x--) 
  818.         {
  819.             percent =  step * x >> 3;
  820.             err = DSpContext_FadeGamma(inContext, percent, &inZeroIntensityColor);
  821.             if (err != noErr) 
  822.                 break;
  823.             while (currTick >= TickCount ()) 
  824.                 SystemTask ();
  825.             currTick = TickCount ();
  826.         }
  827.     }
  828. #endif // kUseFades
  829.     return err;
  830. }